package com.gf.pokemon.util;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.apache.commons.collections.CollectionUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.BeanUtils;

import com.gf.pokemon.domain.Vote;
import com.gf.pokemon.domain.VoteAdminUser;
import com.gf.pokemon.domain.VoteMsg;
import com.gf.pokemon.domain.VoteOption;
import com.gf.pokemon.domain.VoteUser;
import com.gf.pokemon.domain.VoteUserMsg;
import com.gf.pokemon.domain.VoteUserOption;
import com.gf.pokemon.dto.LoginUser;
import com.gf.pokemon.dto.VoteDto;
import com.gf.pokemon.dto.VoteMsgDto;
import com.gf.pokemon.dto.VoteOptionDto;
import com.gf.pokemon.dto.VoteUserDto;
import com.gf.pokemon.dto.VoteUserMsgDto;
import com.gf.pokemon.dto.VoteUserOptionDto;
import com.gf.pokemon.platform.exception.PokeErrorCode;
import com.gf.pokemon.platform.exception.PokeException;

public class ConvertUtils {
	
	private static final Logger logger = Logger.getLogger(ConvertUtils.class);

	public static Vote convert(VoteDto voteDto){
		if(voteDto == null){
			return null;
		}
		Vote vote = new Vote();
		BeanUtils.copyProperties(voteDto, vote);
		return vote;
	}
	
	public static VoteOption convert(VoteOptionDto dto){
		if(dto == null){
			return null;
		}
		VoteOption vote = new VoteOption();
		BeanUtils.copyProperties(dto, vote);
		return vote;
	}
	
	public static VoteMsg convert(VoteMsgDto dto){
		if(dto == null){
			return null;
		}
		VoteMsg vote = new VoteMsg();
		BeanUtils.copyProperties(dto, vote);
		return vote;
	}
	
	public static VoteDto convert(Vote vote){
		if(vote == null){
			return null;
		}
		VoteDto voteDto = new VoteDto();
		BeanUtils.copyProperties(vote, voteDto);
		return voteDto;
	}
	
	public static VoteOptionDto convert(VoteOption vote){
		if(vote == null){
			return null;
		}
		VoteOptionDto voteDto = new VoteOptionDto();
		BeanUtils.copyProperties(vote, voteDto);
		return voteDto;
	}

	public static List<VoteOptionDto> convertOptionList(List<VoteOption> voteOptions) {
		if(CollectionUtils.isEmpty(voteOptions)){
			return new ArrayList<VoteOptionDto>();
		}
		List<VoteOptionDto> dtos = new ArrayList<VoteOptionDto>();
		for(VoteOption option:voteOptions){
			dtos.add(convert(option));
		}
		return dtos;
	}

	public static List<VoteMsgDto> convertMsgList(List<VoteMsg> voteMsgs) {
		if(CollectionUtils.isEmpty(voteMsgs)){
			return new ArrayList<VoteMsgDto>();
		}
		List<VoteMsgDto> dtos = new ArrayList<VoteMsgDto>();
		for(VoteMsg msg:voteMsgs){
			dtos.add(convert(msg));
		}
		return dtos;
	}

	private static VoteMsgDto convert(VoteMsg vote) {
		if(vote == null){
			return null;
		}
		VoteMsgDto voteDto = new VoteMsgDto();
		BeanUtils.copyProperties(vote, voteDto);
		return voteDto;
	}

	public static VoteUserDto convertJsonToVoteUser(String jVote) throws PokeException{
		try{
			JSONObject obj = JSONObject.fromObject(urlEncodeToStr(jVote));
			
			VoteUserDto voteUserDto = (VoteUserDto)JSONObject.toBean(obj, VoteUserDto.class);
			JSONArray options = obj.getJSONArray("voteUserOptionDtos");
			List<VoteUserOptionDto> optionList = new ArrayList<VoteUserOptionDto>();
			if (options != null && options.size() > 0) {		
				for (int i = 0; i < options.size(); i++) {
					optionList.add((VoteUserOptionDto) JSONObject.toBean(
							options.getJSONObject(i), VoteUserOptionDto.class));
				}
			}			
			voteUserDto.setVoteUserOptionDtos(optionList);
			
			JSONArray msgs = obj.getJSONArray("voteUserMsgDtos");
			List<VoteUserMsgDto> msgList = new ArrayList<VoteUserMsgDto>();
			if (msgs != null && msgs.size() > 0) {
				for (int i = 0; i < msgs.size(); i++) {
					msgList.add((VoteUserMsgDto) JSONObject.toBean(
							msgs.getJSONObject(i), VoteUserMsgDto.class));
				}
			}
			voteUserDto.setVoteUserMsgDtos(msgList);
			return voteUserDto;
		}catch(Exception e){
			logger.error(e.getMessage(),e);
			throw new PokeException(PokeErrorCode.INVALID_PARAM,"数据对象无法识别");
		}
	}
	
	public static VoteDto convertJsonToVote(String jVote) throws PokeException {
		try{
			
			JSONObject obj = JSONObject.fromObject(urlEncodeToStr(jVote));
			
			VoteDto voteDto = (VoteDto)JSONObject.toBean(obj, VoteDto.class);
			
			JSONArray options = obj.getJSONArray("voteOptionDtos");
			List<VoteOptionDto> optionList = new ArrayList<VoteOptionDto>();
			if (options != null && options.size() > 0) {		
				for (int i = 0; i < options.size(); i++) {
					optionList.add((VoteOptionDto) JSONObject.toBean(
							options.getJSONObject(i), VoteOptionDto.class));
				}
			}			
			voteDto.setVoteOptionDtos(optionList);
			
			JSONArray msgs = obj.getJSONArray("voteMsgDtos");
			List<VoteMsgDto> msgList = new ArrayList<VoteMsgDto>();
			if (msgs != null && msgs.size() > 0) {
				for (int i = 0; i < msgs.size(); i++) {
					msgList.add((VoteMsgDto) JSONObject.toBean(
							msgs.getJSONObject(i), VoteMsgDto.class));
				}
			}
			voteDto.setVoteMsgDtos(msgList);
			return voteDto;
		}catch(Exception e){
			logger.error(e.getMessage(),e);
			throw new PokeException(PokeErrorCode.INVALID_PARAM,"数据对象无法识别");
		}
	}
	
	public static String urlEncodeToStr(String urlEncodeStr) throws UnsupportedEncodingException{
		String jdata = URLDecoder.decode(urlEncodeStr, "utf-8");
		if(jdata.endsWith("=")){
			jdata = jdata.substring(0, jdata.length()-1);
		}
		return jdata;
	}
	
	public static VoteUser convert(VoteUserDto voteUserDto) {
		if(voteUserDto==null){
			return null;			
		}
		VoteUser voteUser = new VoteUser();
		BeanUtils.copyProperties(voteUserDto, voteUser);
		return voteUser;
	}


	public static VoteUserDto convert(VoteUser voteUser) {
		if(voteUser==null){
			return null;
		}
		VoteUserDto dto = new VoteUserDto();
		BeanUtils.copyProperties(voteUser, dto);
		if(CollectionUtils.isNotEmpty(voteUser.getVoteUserMsgs())){
			List<VoteUserMsgDto> msgDtos = new ArrayList<VoteUserMsgDto>();
			for(VoteUserMsg msg:voteUser.getVoteUserMsgs()){
				VoteUserMsgDto msgDto = convert(msg);
				msgDtos.add(msgDto);
			}
			dto.setVoteUserMsgDtos(msgDtos);
		}
		if(CollectionUtils.isNotEmpty(voteUser.getVoteUserOptions())){
			List<VoteUserOptionDto> optionDtos = new ArrayList<VoteUserOptionDto>();
			for(VoteUserOption option:voteUser.getVoteUserOptions()){
				VoteUserOptionDto optionDto = convert(option);
				optionDtos.add(optionDto);
			}
			dto.setVoteUserOptionDtos(optionDtos);
		}
		return dto;
	}

	public static VoteUserOptionDto convert(VoteUserOption dto) {
		if(dto==null){
			return null;			
		}
		VoteUserOptionDto voteUser = new VoteUserOptionDto();
		BeanUtils.copyProperties(dto, voteUser);
		return voteUser;
	}
	
	public static VoteUserOption convert(VoteUserOptionDto dto) {
		if(dto==null){
			return null;			
		}
		VoteUserOption voteUser = new VoteUserOption();
		BeanUtils.copyProperties(dto, voteUser);
		return voteUser;
	}

	public static VoteUserMsgDto convert(VoteUserMsg dto) {
		if(dto==null){
			return null;			
		}
		VoteUserMsgDto voteUser = new VoteUserMsgDto();
		BeanUtils.copyProperties(dto, voteUser);
		return voteUser;
	}
	
	public static VoteUserMsg convert(VoteUserMsgDto dto) {
		if(dto==null){
			return null;			
		}
		VoteUserMsg voteUser = new VoteUserMsg();
		BeanUtils.copyProperties(dto, voteUser);
		return voteUser;
	}
	
	public static Map<Integer,VoteUserMsg> convertToVoteUserMsgMap(List<VoteUserMsg> dtos){
		Map<Integer,VoteUserMsg> map = new HashMap<Integer,VoteUserMsg>();
		if(CollectionUtils.isEmpty(dtos)){
			return map;
		}
		for(VoteUserMsg voteUserMsg:dtos){
			map.put(voteUserMsg.getVoteMsgId(), voteUserMsg);
		}
		return map;
	}

	public static Map<Integer,VoteUserOption> convertToVoteUserOptionMap(List<VoteUserOption> dtos){
		Map<Integer,VoteUserOption> map = new HashMap<Integer,VoteUserOption>();
		if(CollectionUtils.isEmpty(dtos)){
			return map;
		}
		for(VoteUserOption voteUserOption:dtos){
			map.put(voteUserOption.getVoteOptionId(), voteUserOption);
		}
		return map;
	}
	
	public static Map<Integer,VoteOptionDto> convertToOptionDtoMap(List<VoteOptionDto> dtos){
		Map<Integer,VoteOptionDto> map = new HashMap<Integer,VoteOptionDto>();
		if(CollectionUtils.isEmpty(dtos)){
			return map;
		}
		for(VoteOptionDto voteOptionDto:dtos){
			map.put(voteOptionDto.getId(), voteOptionDto);
		}
		return map;
	}

	public static LoginUser convert(VoteAdminUser user) {
		if(user==null){
			return null;			
		}
		LoginUser voteUser = new LoginUser();
		BeanUtils.copyProperties(user, voteUser);
		return voteUser;
	}

}
